// 1. map
// 2. reduce
// 3. flat
// 4. isArray
// 5. 去重、flat、排序
// 6. shuffle
// 7. 多维数组变一维
// 8. mapflat

Array.prototype.myMap = function(callback){
    let res = [];
    for(let i =0; i < this.length; i++){
        res.push(callback.call(this, this[i], i)) 
    }
    return res;
}
console.log([1,2].myMap((item) => (item +1)))


Array.prototype.myReduce = function(callback, initval){
    let res;
    let i = 0;
    if(initval === undefined){
        res = this[0]
        i++
    } else {
        res = initval
    }
    for(let i = 0; i< this.length; i++){
        res = callback.call(this, res, this[i], i)
    }
    
    return res;
}
console.log([1,2,3].myReduce((pre,cur) => (pre+cur), 1))

Array.prototype.myFlat = function(dep){
    let res = [];
    for(let i = 0; i<this.length; i++){
        if(Array.isArray(this[i]) && dep >= 1){
            let arr = this[i].myFlat(dep-1)
            res = res.concat(arr) // 这里注意 concat 返回新数组
        }else {
            res.push(this[i])
        }
    }
    return res;
}
console.log([1,1,[2,2,[3,3]]].myFlat(0))

Array.myIsArray = function(obj){
    return Object.prototype.toString.call(Object(obj)) === '[object Array]' // 第一个小写，第二个大写
}
console.log(Array.myIsArray([]))
console.log(Object.prototype.toString.call([])) 

// 去重、flat、排序
Array.from(new Set(arr.flat(Infinity))).sort((a,b) => a - b)

// 打乱数组
Array.prototype.myShuffle = function(){
    return this.sort(()=> Math.random() - 0.5)
}

// 创建长度100的数组
console.log(Array.from(Array(100).keys()))

// 如何将多维数组相同索引的元素组成新的多维数组
// 手写 fn([['a','b'],['0','1'],['m','n']]) => ['a0m', 'a0n'....]
let moreArr = [[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[6,4,7,7,8],[1,4,1,1,2],[0,0,0,0,0]]

function transform(arr){
    let res = [];
    arr.forEach(item => {
        item.forEach((ite, index) => {
            res[index] = res[index] || [];
            res[index].push(ite)
        })
    })
    return res;
}
console.log(transform(moreArr))

// https://blog.csdn.net/zhibu_8048/article/details/114094589
// 当元素个数小于 10 个的时候，使用插入排序；
// 当元素个数大于 10 个的时候，使用快速排序。
// 至于indexOf复杂度摊销应该是O(n)

//插入排序
 
function insertionSort( data ) {
    var len = data.length;
    for (var i = 1; i < len; i++) {
        var key = data[i];
        var j = i - 1;
        while ( j >= 0 && data[j] > key) {
            data[j + 1] = data[j];
            j--;
        }
        data[j + 1] = key;
    }
    return data;
}

// 快排
function quickSort( arr ){
    if ( arr.length == 0) {
        return [];
    }
    var left = [];
    var right = [];
    var pivot = arr[0];
    for (var i = 1; i < arr.length; i++) {
        if (arr[i] < pivot) {
            left.push( arr[i] );
        } else {
            right.push( arr[i] );
        }
    }
    return quickSort( left ).concat( pivot, quickSort( right ));
}

// 归并牌组
function mergeSort ( array ) {
    var len = array.length;
    if( len < 2 ){
        return array;
    }
    var middle = Math.floor(len / 2),
        left = array.slice(0, middle),
        right = array.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
}
 
function merge(left, right){
    var result = [];
    while (left.length && right.length) {
        if (left[0] <= right[0]) {
            result.push(left.shift());
        } else {
            result.push(right.shift());
        }
    }
    while (left.length)
        result.push(left.shift());
    while (right.length)
        result.push(right.shift());
    return result;
}


// mapflat
function flatMap(arr, fn) {  
    // 使用 map 方法将每个元素转换成新的数组  
    const mappedArrays = arr.map(fn);  
    
    // 使用 reduce 方法将多个数组合并成一个数组  
    return mappedArrays.reduce((acc, val) => acc.concat(val), []);  
  }  
    
  // 使用示例  
  const numbers = [1, 2, 3];  
  const doubledAndSplitted = flatMap(numbers, x => [x * 2, x * 3]);  
  console.log(doubledAndSplitted); // 输出: [2, 3, 4, 6, 6, 9]


  // 为Array的原型添加sum方法
Array.prototype.sum = function() {
  return this.reduce((acc, cur) => acc + cur, 0);
};

// 使用新的sum方法
const array = [1, 2, 3];
const sum = array.sum(); // 输出6
console.log(sum);
